function Entries(obj) {
    if (typeof obj?.entries === "function") {
        return [...obj.entries()];
    } else if (obj instanceof Object) {
        return Object.entries(obj);
    }
    return undefined;
}
function reProp(prop) {
    const simpleType = typeof prop;
    if (simpleType === "object") {
        return simpleType === null ? "null" : entry(prop);
    } else {
        return simpleType;
    }
}

function reStruct(entries, obj) {
    if (obj instanceof Array) {
        return entries.map((i) => i[1]);
    } else {
        return Object.fromEntries(entries);
    }
}

function combineObject(prev, cur, KeyArray) {
    const result = {};
    for (let index = 0; index < KeyArray.length; index++) {
        // 逐个 key 进行对比
        const key = KeyArray[index];
        const valueP = prev[key];
        const valueC = cur[key];
        if (typeof valueP === typeof valueC) {
            switch (typeof valueC) {
                case "string":
                    // 两边为字符串对比,多个类型时采用了 | 分隔的方式
                    // valueC 为判断出来的必定单个类型，所以不用分割
                    if (valueP.split("|").includes(valueC)) {
                        result[key] = valueP;
                    } else {
                        result[key] = valueP + "|" + valueC;
                    }
                    break;
                case "object":
                    // 值为对象时的判断采用 is 和 JSON 化的方式
                    if (
                        Object.is(prev, cur) ||
                        JSON.stringify(prev) === JSON.stringify(cur)
                    ) {
                        result[key] = valueP;
                    } else {
                        return false;
                    }

                    break;
                default:
                    return false;
            }
        } else {
            // 有一侧为非字符串
            return false;
        }
    }
    return result;
}
function entry(obj) {
    const OldEntries = Entries(obj);
    if (OldEntries === undefined) return null;
    const cache = [];

    const entries = OldEntries.reduce((col, [key, value]) => {
        const VAL = reProp(value);
        if (VAL instanceof Object) {
            // 只有当 VAL 为一个对象才会尝试合并

            // 合并时的判断方式为进行 key 的对比
            const KeyArray = Object.keys(VAL);
            const SetKey = JSON.stringify(KeyArray);
            let canCombine = false;

            const index = cache.indexOf(SetKey);
            if (index !== -1) {
                const Similar = col[index][1];
                // 能否合并
                const result = combineObject(Similar, VAL, KeyArray);
                if (result) {
                    col[index][1] = result;
                    canCombine = true;
                }
            }

            if (canCombine) {
                //能被合并，那么铺垫为空值
                col.push(null);
                cache.push(null);
            } else {
                // 不能合并
                col.push([key, VAL]);
                cache.push(SetKey);
            }
            return col;
        } else {
            col.push([key, VAL]);
        }

        return col;
    }, []).filter((i) => i);
    return reStruct(entries, obj);
}
// 用于快速描述一个对象的对象折叠描述函数
export default function (obj) {
    if (typeof obj !== "object") {
        throw new Error("Describer: Input is not a Object Type");
    }
    return entry(obj);
}
